To be honest, I think this approach is the same as the existing if-statement approach. The only difference is that the conditions are in methods instead of variables. Is there something else that differentiates this approach from the other ones?

Thanks @kahgoh for your feedback! I understand your point, and while both the method-based approach and the if statement approach use condition checks, there are a few key differences that I think set the method-based approach apart:

1. Separation of Concerns:

   • In the method-based approach, I’ve separated the logic for determining if the message is a question, shouting, or silent into individual methods (isYelling(), isAsking(), isSilent()). This makes the main hey() method cleaner and focused on handling the flow of responses.
   • In the if approach, the logic is directly embedded in the main method, which could become harder to read and maintain as more checks are added.

2. Improved Readability:

   • With the helper methods, it’s clear what each condition is doing without having to dive into complex inline if statements. For example, isYelling() immediately tells you that it’s checking for shouting behaviour, and isAsking() clarifies the question check.
   • This helps future readers (and even future maintainers) quickly grasp the purpose of each check.

3. Maintainability:

   • While maintainability may not be a major concern for these one-time exercises, the method-based approach provides a structure that makes it easier to modify individual checks without cluttering the main method. This is generally a good practice for ensuring clean, readable, and maintainable code, even in simple exercises.

4. Scalability:

   • While this specific exercise may not need to scale in the future, separating the logic into individual methods makes it much easier to extend or modify if more conditions are added down the line. Even though we don’t expect more checks here, structuring code this way is generally a good practice for scalability in larger, more complex applications.

In summary, while both approaches work, the method-based approach tends to be cleaner, more modular, and easier to extend. It may seem similar on the surface, but the structure I’ve chosen is designed with maintainability and scalability in mind, which are good practices even for small exercises like this one.

If you have any suggestions or further insights on this approach, I'd be happy to hear them!

Sorry, it has taken me quite a while to get back to this one. I think I can see where you are coming from. Looking around, I noticed Python's approach has two similar if approaches for Bob (if statements and if statements nested). If we were to proceed this approach, perhaps we could do something similar by naming the approach in a similar way to the if statements (for example, if statements with checks in methods).

Btw, looking at the points mentioned under General guidance, there is a point about determining the yelling and questioning once: Use variables for questioning and shouting rather than calling these checks multiple times to improve efficiency. In your example solution, you calling the method again, so it is going to be recalculated. But, my worry about putting them in variables is that it will look even closer to the current if statements approach.

I think the way you've currently is fine as it is, but may be worth pointing out this short coming in the introduction's Which approach to use? .

Sorry, it has taken me quite a while to get back to this one. I think I can see where you are coming from. Looking around, I noticed Python's approach has two similar if approaches for Bob (if statements and if statements nested). If we were to proceed this approach, perhaps we could do something similar by naming the approach in a similar way to the if statements (for example, if statements with checks in methods).

Btw, looking at the points mentioned under General guidance, there is a point about determining the yelling and questioning once: Use variables for questioning and shouting rather than calling these checks multiple times to improve efficiency. In your example solution, you calling the method again, so it is going to be recalculated. But, my worry about putting them in variables is that it will look even closer to the current if statements approach.

I think the way you've currently is fine as it is, but may be worth pointing out this short coming in the introduction's Which approach to use? .

In the intro and other approaches for this exercise, we have used the term "shouting" instead of "yelling". I'd suggest using the same terminology to keep it consistent within the approaches.

Similar to above, we've used the term "questioning" in the intro and other approaches.

I don't think the casing in the headings need changing - there are consistent with most other other approaches. Could you undo the changes to the headings?